@powerhousedao/powerhouse-vetra-packages 6.2.3-dev.5 → 6.2.3-dev.50

package/dist/browser/assets/{entry-5_Eh4a2Z.js → entry-E7pSm84X.js}

@@ -1,8 +1,103 @@
-import { o as instrumentPgPool } from "./drive-container-types-yZrksiJR.js";
-import { n as errorToInfo, t as createForwardingLogger } from "./forwarding-logger-BBkMSxuJ.js";
-import { n as defaultLoadFactory, t as buildWorkerExecutor } from "./build-worker-executor-DnU3ZU4H.js";
+import { D as CollectionMembershipCache, E as DocumentMetaCache, St as ReactorEventTypes, a as REACTOR_SCHEMA, d as KyselyKeyframeStore, f as EventBus, l as instrumentPgPool, m as KyselyOperationIndex, n as errorToInfo, p as KyselyWriteCache, t as createForwardingLogger, u as KyselyOperationStore } from "./forwarding-logger-ByfBFgMS.js";
+import { a as KyselyExecutionScope, n as SimpleJobExecutor, t as DEFAULT_DRIVE_CONTAINER_TYPES } from "./drive-container-types-Ci1pdv4X.js";
+import { n as loadDocumentModelSpec, r as DocumentModelRegistry, t as defaultLoadFactory } from "./load-spec-ZLjuyhxz.js";
 import { ConsoleLogger } from "document-model";
 import { isMainThread, parentPort } from "node:worker_threads";
+//#region src/executor/worker/build-worker-executor.ts
+async function loadModelManifest(entries, loadFactory, registry, logger) {
+	for (const entry of entries) {
+		let module;
+		try {
+			module = await loadFactory(entry.spec);
+		} catch (error) {
+			logger.error("worker failed to load document model: @entry @error", entry, error);
+			throw error;
+		}
+		const [result] = registry.registerModules(module);
+		if (result.status === "error") {
+			logger.error("worker failed to register document model: @entry @error", entry, result.error);
+			throw result.error;
+		}
+	}
+}
+/**
+* Assembles the in-worker storage stack plus a {@link SimpleJobExecutor}
+* bound to a pre-built Kysely instance. The parent owns the wire protocol
+* and routing; the worker owns everything below `SimpleJobExecutor`.
+*
+* The local event bus exists only to satisfy the executor's contract: its
+* JOB_WRITE_READY emissions are captured here and shipped to the parent
+* via {@link WorkerExecutorStack.takeLastWriteReady}.
+*/
+async function buildWorkerExecutor(options) {
+	const { init, database: baseDatabase, logger } = options;
+	const driveContainerTypes = options.driveContainerTypes ?? DEFAULT_DRIVE_CONTAINER_TYPES;
+	const loadFactory = options.loadFactory ?? defaultLoadFactory;
+	const registry = new DocumentModelRegistry();
+	await loadModelManifest(init.models, loadFactory, registry, logger);
+	let signer;
+	if (init.signer) try {
+		signer = await loadFactory(init.signer);
+	} catch (error) {
+		logger.error("worker failed to load signer: @spec @error", init.signer.module, error);
+		throw error;
+	}
+	let trustPolicy;
+	if (init.trustPolicy) try {
+		trustPolicy = await loadFactory(init.trustPolicy);
+	} catch (error) {
+		logger.error("worker failed to load trust policy: @spec @error", init.trustPolicy.module, error);
+		throw error;
+	}
+	const database = baseDatabase.withSchema(REACTOR_SCHEMA);
+	const operationStore = new KyselyOperationStore(database);
+	const keyframeStore = new KyselyKeyframeStore(database);
+	const writeCache = new KyselyWriteCache(keyframeStore, operationStore, registry, {
+		maxDocuments: 100,
+		ringBufferSize: 10,
+		keyframeInterval: 10
+	});
+	await writeCache.startup();
+	const operationIndex = new KyselyOperationIndex(database);
+	const documentMetaCache = new DocumentMetaCache(operationStore, { maxDocuments: 1e3 });
+	await documentMetaCache.startup();
+	const collectionMembershipCache = new CollectionMembershipCache(operationIndex);
+	const executionScope = new KyselyExecutionScope(database, operationStore, operationIndex, keyframeStore, writeCache, documentMetaCache, collectionMembershipCache);
+	const eventBus = new EventBus();
+	let lastWriteReady = null;
+	eventBus.subscribe(ReactorEventTypes.JOB_WRITE_READY, (_t, event) => {
+		lastWriteReady = {
+			operations: event.operations,
+			jobMeta: event.jobMeta
+		};
+	});
+	let signatureRefusals = [];
+	eventBus.subscribe(ReactorEventTypes.SIGNATURE_REFUSED, (_t, event) => {
+		signatureRefusals.push(event);
+	});
+	const executorConfig = options.executorConfig ?? {};
+	return {
+		executor: new SimpleJobExecutor(logger, registry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, driveContainerTypes, executorConfig, executionScope, signer, trustPolicy),
+		registry,
+		takeLastWriteReady() {
+			const captured = lastWriteReady;
+			lastWriteReady = null;
+			return captured;
+		},
+		takeSignatureRefusals() {
+			const captured = signatureRefusals;
+			signatureRefusals = [];
+			return captured;
+		},
+		evictPurged(documentIds) {
+			for (const documentId of documentIds) {
+				writeCache.invalidate(documentId);
+				documentMetaCache.invalidate(documentId);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/executor/worker/run-worker.ts
 const POOL_SAMPLE_INTERVAL_MS = 1e3;
 async function defaultCreateDatabase(config, workerId) {
@@ -38,7 +133,7 @@ async function defaultCreateDatabase(config, workerId) {
 /**
 * Drives the worker's message loop. Owns lifecycle of the database handle
 * and executor stack. The default factories build a real Postgres pool and
-* use dynamic `import()` for model/verifier specs; tests inject overrides
+* use dynamic `import()` for model/signer specs; tests inject overrides
 * for an in-process PGlite path.
 */
 function runWorker(parentPort, overrides = {}) {
@@ -51,6 +146,7 @@ function runWorker(parentPort, overrides = {}) {
 	let pendingPoolSamples = [];
 	let detachPoolListener = null;
 	const activeLoadFactory = overrides.loadFactory ?? defaultLoadFactory;
+	const loadModelSpec = overrides.loadFactory ? async (spec) => await activeLoadFactory(spec) : loadDocumentModelSpec;
 	function post(msg) {
 		parentPort.postMessage(msg);
 	}
@@ -146,11 +242,16 @@ function runWorker(parentPort, overrides = {}) {
 			return;
 		}
 		try {
+			const result = await executorStack.executor.executeJob(job);
+			const writeReady = executorStack.takeLastWriteReady();
+			const signatureRefusals = executorStack.takeSignatureRefusals();
 			post({
 				type: "result",
 				correlationId,
-				result: await executorStack.executor.executeJob(job),
-				writeReady: executorStack.takeLastWriteReady() ?? void 0
+				result,
+				writeReady: writeReady ?? void 0,
+				signatureRefusals: signatureRefusals.length > 0 ? signatureRefusals : void 0,
+				error: !result.success && result.error ? errorToInfo(result.error) : void 0
 			});
 		} catch (error) {
 			post({
@@ -178,7 +279,7 @@ function runWorker(parentPort, overrides = {}) {
 		}
 		let module;
 		try {
-			module = await activeLoadFactory(msg.model.spec);
+			module = await loadModelSpec(msg.model.spec);
 		} catch (error) {
 			post({
 				type: "model-load-failed",
@@ -277,6 +378,9 @@ function runWorker(parentPort, overrides = {}) {
 					});
 				});
 				break;
+			case "evict-purged":
+				executorStack?.evictPurged(msg.documentIds);
+				break;
 			default: {
 				const raw = msg;
 				if (raw["type"] === "__test_throw") {

package/dist/browser/assets/{projection-entry-5PVbP10h.js → projection-entry-UE4mfnXc.js}

@@ -1,11 +1,23 @@
-import { _ as DocumentMetaCache, c as KyselyKeyframeStore, g as KyselyOperationIndex, h as KyselyWriteCache, l as DocumentModelRegistry, m as EventBus, n as REACTOR_SCHEMA, o as instrumentPgPool, s as KyselyOperationStore, v as CollectionMembershipCache } from "./drive-container-types-yZrksiJR.js";
-import { n as ReactorEventTypes } from "./types-DMKLa0Ok.js";
-import { i as KyselyDocumentView, n as ConsistencyTracker, s as ReadModelCoordinator, t as KyselyDocumentIndexer } from "./document-indexer-C5Gsa1B3.js";
-import { n as errorToInfo, t as createForwardingLogger } from "./forwarding-logger-BBkMSxuJ.js";
-import { n as defaultLoadFactory } from "./build-worker-executor-DnU3ZU4H.js";
+import { D as CollectionMembershipCache, E as DocumentMetaCache, S as createKyselyWatermarkProbe, St as ReactorEventTypes, a as REACTOR_SCHEMA, d as KyselyKeyframeStore, f as EventBus, l as instrumentPgPool, m as KyselyOperationIndex, n as errorToInfo, p as KyselyWriteCache, t as createForwardingLogger, u as KyselyOperationStore, v as findPurged, x as SettledWatermark } from "./forwarding-logger-ByfBFgMS.js";
+import { r as DocumentModelRegistry, t as defaultLoadFactory } from "./load-spec-ZLjuyhxz.js";
+import { a as KyselyDocumentView, c as ReadModelCoordinator, f as BaseReadModel, n as ConsistencyTracker, t as KyselyDocumentIndexer, y as CatchUpScheduler } from "./document-indexer-DwAMDVRI.js";
+import { isPurgeMarker } from "@powerhousedao/shared/document-model";
 import { ConsoleLogger } from "document-model";
 import { isMainThread, parentPort } from "node:worker_threads";
 //#region src/projection/projection-worker/build-projection-stack.ts
+/**
+* In-worker projection stack builder.
+*
+* Mirrors {@link buildWorkerExecutor} but for the projection-side
+* read models. The worker owns one full copy of the storage stack — read
+* cache, operation index, document-meta cache — bound to its own
+* pg.Pool/Kysely, plus an in-process `ReadModelCoordinator` that
+* subscribes to a local `EventBus`.
+*
+* The host relays JOB_WRITE_READY into the local bus by calling
+* `relayWriteReady`, and forwards the local bus's JOB_READ_READY plus
+* READMODEL_* events back to the host bus via the IPC bridge.
+*/
 async function loadModelManifest(entries, loadFactory, registry, logger) {
 	for (const entry of entries) {
 		let module;
@@ -22,14 +34,11 @@ async function loadModelManifest(entries, loadFactory, registry, logger) {
 		}
 	}
 }
-function instantiateReadModel(kind, database, operationStore, operationIndex, writeCache) {
+function instantiateReadModel(kind, database, operationStore, operationIndex, writeCache, indexing) {
 	switch (kind) {
-		case "document-view": return new KyselyDocumentView(database, operationStore, operationIndex, writeCache, new ConsistencyTracker(), false);
-		case "document-indexer": return new KyselyDocumentIndexer(database, operationIndex, writeCache, new ConsistencyTracker());
-		default: {
-			const exhaustive = kind;
-			throw new Error(`unknown built-in read model kind: ${String(exhaustive)}`);
-		}
+		case "document-view": return new KyselyDocumentView(database, operationStore, operationIndex, writeCache, new ConsistencyTracker(), "NotFound", indexing);
+		case "document-indexer": return new KyselyDocumentIndexer(database, operationIndex, writeCache, new ConsistencyTracker(), indexing);
+		default: throw new Error(`unknown built-in read model kind: ${String(kind)}`);
 	}
 }
 async function initReadModels(models, logger) {
@@ -44,6 +53,32 @@ async function initReadModels(models, logger) {
 		}
 	}
 }
+/** Posts what each sweep applied, so the host's tracker for the model advances. */
+function relaySweeps(model, events, onSwept) {
+	return {
+		get consumerId() {
+			return model.consumerId;
+		},
+		get appliedThrough() {
+			return model.appliedThrough;
+		},
+		get trackedAbove() {
+			return model.trackedAbove;
+		},
+		async sweep(settledThrough, present, signal) {
+			const coordinates = [];
+			const unsubscribe = model.onSwept((swept) => coordinates.push(...swept));
+			try {
+				const result = await model.sweep(settledThrough, present, signal);
+				if (coordinates.length > 0 || result.to > result.from || result.replayed > 0 || result.blockedAt !== void 0) events.onReadModelSwept(model.name, coordinates, result);
+				await onSwept(coordinates);
+				return result;
+			} finally {
+				unsubscribe();
+			}
+		}
+	};
+}
 async function buildProjectionStack(options) {
 	const { init, database: baseDatabase, logger, events } = options;
 	const loadFactory = options.loadFactory ?? defaultLoadFactory;
@@ -51,18 +86,44 @@ async function buildProjectionStack(options) {
 	await loadModelManifest(init.models, loadFactory, registry, logger);
 	const database = baseDatabase.withSchema(REACTOR_SCHEMA);
 	const operationStore = new KyselyOperationStore(database);
-	const writeCache = new KyselyWriteCache(new KyselyKeyframeStore(database), operationStore, registry, {
+	const keyframeStore = new KyselyKeyframeStore(database);
+	const writeCache = new KyselyWriteCache(keyframeStore, operationStore, registry, {
 		maxDocuments: 100,
 		ringBufferSize: 10,
 		keyframeInterval: 10
 	});
 	await writeCache.startup();
 	const operationIndex = new KyselyOperationIndex(database);
-	await new DocumentMetaCache(operationStore, { maxDocuments: 1e3 }).startup();
+	const documentMetaCache = new DocumentMetaCache(operationStore, { maxDocuments: 1e3 });
+	await documentMetaCache.startup();
 	new CollectionMembershipCache(operationIndex);
-	const preReady = init.preReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache));
-	const postReady = init.postReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache));
-	await initReadModels([...preReady, ...postReady], logger);
+	const evict = (documentIds) => {
+		for (const documentId of documentIds) {
+			writeCache.invalidate(documentId);
+			documentMetaCache.invalidate(documentId);
+		}
+	};
+	const evictSweptMarkers = async (coordinates) => {
+		const candidates = coordinates.filter((c) => c.scope === "document" && c.operationIndex === 0).map((c) => c.documentId);
+		if (candidates.length === 0) return;
+		let purged;
+		try {
+			purged = await findPurged(database, candidates);
+		} catch (error) {
+			logger.error("projection worker purge lookup failed: @error", error);
+			return;
+		}
+		evict(purged);
+	};
+	const preReady = init.preReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache, init.indexing));
+	const postReady = init.postReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache, init.indexing));
+	const watermark = new SettledWatermark(createKyselyWatermarkProbe(database), logger);
+	const catchUp = new CatchUpScheduler(watermark, operationIndex, init.catchUp, logger);
+	const models = [...preReady, ...postReady];
+	for (const model of models) if (model instanceof BaseReadModel) model.attachCatchUp(watermark, init.catchUp.maxTrackedAboveCursor);
+	await initReadModels(models, logger);
+	for (const model of models) if (model instanceof BaseReadModel) catchUp.addConsumer(relaySweeps(model, events, evictSweptMarkers), "projection");
+	catchUp.start();
 	const eventBus = new EventBus();
 	const subscriptions = [];
 	subscriptions.push(eventBus.subscribe(ReactorEventTypes.JOB_READ_READY, (_t, event) => {
@@ -80,19 +141,24 @@ async function buildProjectionStack(options) {
 		registry,
 		coordinator,
 		eventBus,
+		writeCache,
 		async relayWriteReady(event) {
+			evict(event.operations.filter((item) => isPurgeMarker(item)).map((item) => item.context.documentId));
 			await eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, event);
 		},
 		getChainDepth() {
 			return coordinator.getChainDepth();
 		},
+		catchUpStatus() {
+			return catchUp.status();
+		},
 		async drain() {
 			await coordinator.drain();
 		},
-		shutdown() {
+		async shutdown() {
+			await catchUp.stop();
 			coordinator.stop();
 			for (const unsub of subscriptions) unsub();
-			return Promise.resolve();
 		}
 	};
 }
@@ -213,6 +279,11 @@ function runProjectionWorker(parentPort, overrides = {}) {
 		if (intervalMs <= 0) return;
 		depthTimer = setInterval(() => {
 			if (!stack) return;
+			post({
+				type: "catchup-status",
+				shardId,
+				status: stack.catchUpStatus()
+			});
 			const depth = stack.getChainDepth();
 			if (depth === lastReportedDepth) return;
 			lastReportedDepth = depth;
@@ -261,6 +332,15 @@ function runProjectionWorker(parentPort, overrides = {}) {
 						success: event.success
 					});
 				},
+				onReadModelSwept: (readModelName, coordinates, result) => {
+					post({
+						type: "readmodel-swept",
+						shardId,
+						readModelName,
+						coordinates,
+						result
+					});
+				},
 				onBatchCompleted: (event) => {
 					post({
 						type: "readmodel-batch-completed",
@@ -380,8 +460,6 @@ function runProjectionWorker(parentPort, overrides = {}) {
 					});
 					process.exit(0);
 				});
-				break;
-			default: break;
 		}
 	}
 	parentPort.on("message", handleParentMessage);

package/dist/browser/document-models/index.js

@@ -1,2 +1,3 @@
-import { p as documentModelDocumentModelModule, r as driveDocumentModelModule } from "../document-drive-BEXJ-rHp.js";
+import { documentModelDocumentModelModule } from "document-model";
+import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
 export { documentModelDocumentModelModule, driveDocumentModelModule };